Clojure Applied (for Embach Mark) by Ben Vandgrift Alex Miller

Author:Ben Vandgrift, Alex Miller
Language: eng
Format: epub
Tags: Pragmatic Bookshelf
ISBN: 978-1-68050-074-5
Publisher: The Pragmatic Bookshelf, LLC (573151)

Go Blocks

Traditionally, Java (or Clojure) programs create threads (which map to real operating-system threads) to contain the actual processing for each part of the program. The core.async library follows a different tradition, based on the heritage of C. A. R. Hoare’s classic work on Communicating Sequential Processes (CSP) [Hoa78].[19]

We won’t dive into the details of that work. The important thing is learning to think in a different way about how we structure programs. Threads are scarce and expensive resources. They consume stack space and other resources, and they’re comparatively slow to start. When these threads block for I/O, we waste those system resources.

Instead, core.async encourages us to think in terms of lightweight processes that are mapped to a thread pool and run only when work is ready to be done. Instead of blocking while waiting for messages to go in or out on channels, those processes can be parked until the process is ready to run again. This allows us to run processes only when there’s work to do. Also, it allows us to implement some interesting new behavior for selecting across multiple I/O operations and proceeding when the first one completes.

In core.async, we call these processes go blocks (in a nod to similar concepts in the Go language). Inside go blocks we use channels, though the put and take operations are <! and >!.

Here’s an example of a function that creates a go block to receive and process messages by printing them:

​ (​require​ '[clojure.core.async :refer (go <!)])

Download

Copyright Disclaimer:
This site does not store any files on its server. We only index and link to content provided by other sites. Please contact the content providers to delete copyright contents if any and email us, we'll remove relevant links or contents immediately.